# -*- coding: utf-8 -*-
"""
清理脏数据模块 - 函数式设计
采用流水线模式，支持灵活扩展清理规则

作者: Claude  
创建时间: 2024-09-14
"""

import re
import os
from typing import Tuple, List
from functools import reduce
from pathlib import Path

try:
    from config.patterns import pattern_config
except ImportError:
    import sys
    import os
    sys.path.append(os.path.dirname(os.path.dirname(__file__)))
    from config.patterns import pattern_config


def extract_filename_components(full_filename: str) -> Tuple[str, str]:
    """
    提取文件名组件
    
    :param full_filename: 完整文件名
    :return: (基础文件名, 扩展名)
    """
    path_obj = Path(full_filename)
    return path_obj.stem, path_obj.suffix


def apply_cleaning_pattern(filename: str, pattern_name: str, pattern_regex: str) -> str:
    """
    应用单个清理模式 - 纯函数设计
    
    :param filename: 待清理的文件名
    :param pattern_name: 模式名称
    :param pattern_regex: 正则表达式
    :return: 清理后的文件名
    """
    try:
        # 特殊变换处理
        if pattern_name == "4k60fps_transform":
            return re.sub(pattern_regex, '-4K', filename, flags=re.IGNORECASE)
        
        # 标准清理：删除匹配的内容
        cleaned = re.sub(pattern_regex, '', filename, flags=re.IGNORECASE)
        return cleaned
    except Exception:
        # 如果正则表达式出错，返回原文件名
        return filename


def normalize_separators(filename: str) -> str:
    """
    规范化分隔符 - 只清理多余空格，保持原有的-和_格式
    
    :param filename: 文件名
    :return: 规范化后的文件名
    """
    # 只清理多余的空格，不改变-和_
    normalized = re.sub(r'\s+', '', filename)  # 删除所有空格
    
    # 清理重复的分隔符，但保持类型不变
    normalized = re.sub(r'[-]{2,}', '-', normalized)  # 多个-合并为一个-
    normalized = re.sub(r'[_]{2,}', '_', normalized)  # 多个_合并为一个_
    
    # 清理开头和结尾的分隔符
    normalized = normalized.strip('_-')
    
    return normalized


def clean_filename_pipeline(filename: str) -> str:
    """
    文件名清理流水线 - 函数式组合设计
    按优先级顺序应用所有清理规则
    
    :param filename: 原始文件名（不包含扩展名）
    :return: 清理后的文件名
    """
    # 获取所有清理模式（已按优先级排序）
    cleaning_patterns = pattern_config.get_cleaning_patterns()
    
    def apply_single_pattern(current_filename: str, pattern) -> str:
        """应用单个清理模式的内部函数"""
        return apply_cleaning_pattern(
            current_filename, 
            pattern.name, 
            pattern.pattern
        )
    
    # 使用函数式编程的reduce进行流水线处理
    cleaned_filename = reduce(apply_single_pattern, cleaning_patterns, filename)
    
    # 最后标准化分隔符
    return normalize_separators(cleaned_filename)


def apply_special_transforms(filename: str) -> str:
    """
    应用特殊变换规则
    
    :param filename: 文件名
    :return: 变换后的文件名
    """
    transformed = filename
    special_transforms = pattern_config.get_special_transforms()
    
    # 应用4K变换
    for pattern, replacement in special_transforms["4k_transforms"]:
        transformed = re.sub(pattern, replacement, transformed, flags=re.IGNORECASE)
    
    # 应用CD分段变换 - 更智能的判断
    for pattern, replacement in special_transforms["cd_transforms"]:
        # 只有当文件名以数字结尾且数字在合理范围内时才转换
        if pattern in [r'_(\d+)$', r'-(\d+)$']:
            match = re.search(pattern, transformed)
            if match:
                num_str = match.group(1)
                num = int(num_str)
                
                # 检查是否为无码格式，如果是则跳过转换
                uncensored_pattern = r'\d{6}[-_]\d{3}$'
                if re.search(uncensored_pattern, transformed):
                    continue  # 跳过无码格式的转换
                
                # 新增：智能判断是否为真正的分段标记
                # 如果数字部分是3位数字（如003），很可能是番号的一部分，不转换
                if len(num_str) >= 3:
                    continue  # 跳过3位数字及以上的转换
                
                # 新增：检查是否为有码番号格式（字母-数字），如果是则跳过
                censored_pattern = r'^[A-Z]{2,6}[-_]?\d+$'
                if re.match(censored_pattern, transformed, re.IGNORECASE):
                    continue  # 跳过有码番号格式的转换
                
                if 1 <= num <= 9:  # 合理的分段范围，支持1-9
                    transformed = re.sub(pattern, replacement, transformed)
        else:
            transformed = re.sub(pattern, replacement, transformed, flags=re.IGNORECASE)
    
    return transformed


def clean_single_filename(filename: str) -> str:
    """
    清理单个文件名的主函数 - 完整流水线处理
    
    :param filename: 文件名（不含扩展名）
    :return: 清理后的文件名
    """
    # 步骤1: 执行清理流水线
    cleaned_name = clean_filename_pipeline(filename)
    
    # 步骤2: 应用特殊变换
    transformed_name = apply_special_transforms(cleaned_name)
    
    return transformed_name


def batch_clean_filenames(filenames: List[str]) -> List[Tuple[str, str]]:
    """
    批量清理文件名 - 函数式映射处理
    
    :param filenames: 文件名列表
    :return: [(原始文件名, 清理后文件名), ...]
    """
    def process_single(filename: str) -> Tuple[str, str]:
        """处理单个文件名的映射函数"""
        cleaned_name = clean_single_filename(filename)
        return filename, cleaned_name
    
    # 使用函数式编程的map进行批量处理
    return list(map(process_single, filenames))


def validate_cleaning_result(original: str, cleaned: str) -> bool:
    """
    验证清理结果的有效性
    
    :param original: 原始文件名  
    :param cleaned: 清理后文件名
    :return: 验证是否通过
    """
    # 基本验证：清理后不能为空
    if not cleaned or len(cleaned.strip()) == 0:
        return False
    
    # 长度验证：清理后不能过短（至少3个字符）
    if len(cleaned) < 3:
        return False
    
    # 字符验证：不能全是特殊字符
    if re.match(r'^[^a-zA-Z0-9]+$', cleaned):
        return False
    
    return True


# 导出的函数式接口
__all__ = [
    "clean_single_filename",
    "batch_clean_filenames", 
    "validate_cleaning_result",
    "clean_filename_pipeline"
]